#include <iostream>

using namespace std;

// namespace Cherry {
// struct MyVector {
//   int _len;
//   int _size;
//   int* _arr;

//   MyVector(int n = 10) : _len(0), _size(n), _arr(new int[n]) {}

//   MyVector(const MyVector& _myv)
//       : _len(_myv._len), _size(_myv._size), _arr(new int[_myv._size]) {
//     for (int i = 0; i < _len; ++i) {
//       _arr[i] = _myv._arr[i];
//     }
//     cout << "MyVector(const MyVector& _myv) -- 拷贝构造" << endl;
//   }

//   MyVector(MyVector&& myv) : _len(0), _size(0), _arr(nullptr) {
//     swap(myv._arr, _arr);
//     swap(myv._len, _len);
//     swap(myv._size, _size);
//     cout << "MyVector(MyVector&& myv) -- 移动构造" << endl;
//   }

//   MyVector(initializer_list<int> il)
//       : _len(il.size()), _size(il.size()), _arr(new int[il.size()]) {
//     int* ptr = _arr;
//     for (int val : il) {
//       *ptr++ = val;
//     }
//   }

//   MyVector& operator=(const MyVector& other) {
//     if (this != &other) {
//       // 释放当前对象的资源
//       delete[] _arr;

//       // 分配新的资源并复制数据
//       _size = other._size;
//       _len = other._len;
//       _arr = new int[_size];
//       for (int i = 0; i < _len; ++i) {
//         _arr[i] = other._arr[i];
//       }
//     }
//     cout << "MyVector& operator=(const MyVector& other) -- 拷贝赋值" << endl;
//     return *this;
//   }

//   MyVector& operator=(MyVector&& myv) noexcept {
//     if (this != &myv) {
//       // 交换当前对象和源对象的成员变量
//       swap(_arr, myv._arr);
//       swap(_len, myv._len);
//       swap(_size, myv._size);

//       // 将源对象的成员变量设置为默认值
//       myv._arr = nullptr;
//       myv._len = 0;
//       myv._size = 0;
//     }
//     cout << "MyVector& operator=(MyVector&& myv) -- 移动赋值" << endl;
//     return *this;
//   }

//   ~MyVector() {
//     delete[] _arr;
//     _arr = nullptr;
//     _size = 0;
//     _len = 0;
//   }

//   bool Push_back(int num) {
//     if (_len < _size) {
//       _arr[_len] = num;
//       ++_len;
//       return true;
//     } else {
//       cout << "error" << endl;
//       return false;
//     }
//   }

//   void Print() {
//     for (int i = 0; i < _len; ++i) {
//       cout << _arr[i] << " ";
//     }
//     cout << endl;
//   }
// };
// }  // namespace Cherry

// // int main() {
// //   Cherry::MyVector mv1;
// //   mv1.Push_back(1), mv1.Push_back(3), mv1.Push_back(5), mv1.Push_back(7);
// //   Cherry::MyVector mv2(mv1);
// //   cout << "mv1打印:" << endl;
// //   mv1.Print();
// //   cout << "mv2打印:" << endl;
// //   mv2.Print();

// //   Cherry::MyVector mv3(move(mv1));

// //   cout << "mv1打印:" << endl;
// //   mv1.Print();
// //   cout << "mv3打印:" << endl;
// //   mv3.Print();

// //   return 0;
// // }

// int main() {
//   Cherry::MyVector mv1({1, 2, 3, 4, 5});
//   Cherry::MyVector mv2({2, 2, 2, 2, 2});

//   mv1 = {2, 4, 6, 8, 9};
//   mv2.Print();
//   mv1.Print();
//   cout << "----------------" << endl;
//   mv1 = move(mv2);
//   mv2.Print();
//   mv1.Print();
//   cout << "----------------" << endl;
//   return 0;
// }


// void funcB(int&& arg) {
//   std::cout << "funcB: 右值引用" << std::endl;
//   cout << &arg << endl;
// }

// void funcB(int& arg) {
//   std::cout << "funcB: 左值引用" << std::endl;
//   cout << &arg << endl;
// }

// void funcA(int&& arg) {
//   std::cout << "funcA: 右值引用" << std::endl;
//   cout << &arg << endl;
//   funcB(forward<decltype(arg)>(arg));  // 将参数传递给 funcB
// }

// void funcA(int& arg) {
//   std::cout << "funcA: 左值引用" << std::endl;
//   cout << &arg << endl;
//   funcB(arg);  // 将参数传递给 funcB
// }

// int main() {
//   // int x = 10;
//   funcA(10);  // 调用 funcA，并传入一个右值
//   return 0;
// }




// #include <type_traits>

// template <class T>
// void MyFunc(T&& arg) {
//   if (std::is_rvalue_reference<T&&>::value) {
//     std::cout << "右值引用" << std::endl;
//     MyFunc(arg);
//   } else {
//     std::cout << "左值引用" << std::endl;
//   }
// }

// int main() {
//   MyFunc(10);
//   return 0;
// }

#include <utility>

// 接受任意类型参数的函数
void process(int& x) {
    std::cout << "左值引用版本: " << x << std::endl;
}

void process(int&& x) {
    std::cout << "右值引用版本: " << x << std::endl;
}

// 使用完美转发实现参数传递
template<typename T>
void forwarder(T&& arg) {
    process(std::forward<T>(arg)); // 使用std::forward进行完美转发
}

int main() {
    int x = 10;

    forwarder(x);        // 传入左值
    forwarder(20);       // 传入右值

    return 0;
}
